Data model for a common language

ABSTRACT

Embodiments and principles described herein relate to software repositories for common languages. Embodiments include maintaining database schema and structures which comprise application framework information and provides for the storage, querying, and retrieval of an abstraction of a namespace corresponding to an application framework. Embodiments also provide for the storage, querying and retrieval of information corresponding to parameters of methods within an application framework. Embodiments also include the storage, querying and retrieval of information corresponding to type information for constructed types within an application framework.

BACKGROUND

Computer systems and related technology affect many aspects of society. Indeed, the computer system's ability to process information has transformed the way we live and work. Computer systems now commonly perform a host of tasks (e.g., word processing, scheduling, accounting, etc.) that prior to the advent of the computer system were performed manually. More recently, computer systems have been coupled to one another and to other electronic devices to form both wired and wireless computer networks over which the computer systems and other electronic devices can transfer electronic data. Accordingly, the performance of many computing tasks are distributed across a number of different computer systems and/or a number of different computing components.

Software code is typically written by one or more software developers using some type of integrated development environment (IDE). In many cases, developers are given a set of design instructions, and, using a programming language, draft software code that will implement the functions described in the design specifications. Depending on the nature and scope of the design specifications (or any subsequent modifications thereto), the software program can be both large and complex.

Enterprise software programs, for example, may involve many hundreds or thousands of software files, each file designed to interact with other files within the program and externally with other software programs and/or operating systems. Often, supplemental programs or databases, such as, for example, software repositories, are used to organize, search and maintain the data and metadata which describes the program and its files. Program metadata consists of information such as the structure of program components, behavior of those components, how components and subcomponents may relate to each other, and other characteristics useful for organization and control. File metadata consists of information such as the date the file was last modified, the size of the file, the file's relation to other files within the software program, documentation concerning particular modules or constructs, and other characteristics useful for organization and control.

One approach for organizing a software repository includes storing a software program's objects and their corresponding metadata together using an entity-property-value approach (also called the universal schema approach). Using an entity-property-value approach most data is stored in a table of property ID/value pairs. Thus, a software repository can be organized such that objects are listed alphabetically with the metadata alongside, each portion of metadata corresponding to the appropriate object. For example, a software repository can list a software object and a name and corresponding value for the each property of the software object. Related objects can be, for example, shown as a list of related objects headed by the kind of relationship (e.g., objects related to another object by an automatic generation process).

Using an entity-property-value approach data is stored in a highly uniform way making it relatively easy to build generic repository APIs and browsers. However, due to the typically finer granularity with which software objects are stored (i.e., per property), querying an entity-property-value based software repository can be complex and inefficient. Many objects can include additional relationships to one another (e.g., based on user-preference, code version, access patterns, replication, etc.) causing them to be frequently accessed together. However, these additional relationships are not easily represented using entity-property-value approach. Thus, although these objects are related in additional ways, they typically cannot be easily accessed as a group. Accordingly, sometimes complex queries may be required to access objects individually and then subsequently group them together for performing further operations.

Another approach for organizing a software repository includes storing metadata in XML columns or some other post-relational structure. As opposed to name/value pairs, post-relational structures permit complex data values to be stored in a single table cell. Because some database servers have efficient ways to store XML, an XML column or other post-relational approach can be efficient for hierarchical data (e.g., type definitions of an object oriented software program). Using a post-relational approach, hierarchical data can be flexibly grouped.

However, due to the typically coarser granularity with which software objects are stored (i.e., in a hierarchical tree), querying a post-relational based software repository can be also be complex and inefficient. For example, objects can be related in ways that do not conform well to a hierarchical structure (e.g., based on user-preference, code version, access patterns, replication, etc.) and thus related objects can span different hierarchical trees. Accordingly, queries may be required to access different sub-trees from different post-relational structures and then merge the results together for performing further operations.

Further, most database tools are designed for use with databases based on conventional schemas (as opposed to universal schema or post-relational schema) making their use with entity-property-value and post-relational based software repositories more difficult. As such, not only are these queries typically more complex, a developer must often resort to developing sometimes complex queries without the automated development capabilities included in these database tools.

Accordingly, at the very least, creating software repository queries can consume significant developer resources (that would otherwise be used to develop code). In many cases, creating software repository queries will be beyond the technical expertise of a developer who, while well-trained in code development, may lack expert knowledge in the composition of appropriate database queries.

BRIEF SUMMARY

Embodiments described herein extend to methods, systems, computer program products, and data structures for software repositories. Embodiments are described which enable information pertaining to common language application frameworks and infrastructures to be stored and queried within a computing system.

Embodiments are provided which maintain software repository database schema and database structures which enable information pertaining to an application framework to be stored and which further allows an abstraction of a namespace to be stored along with the application framework so that software repository tools may straightforwardly and efficiently query for data using either infrastructure semantics or programming language semantics.

Embodiments are provided which maintain software repository database schema and database structures which enable method parameter information to be stored, queried, and retrieved together with other method data. Post-Relational database structures are employed in certain embodiments to store information in a column with other method data to enable the formation of queries and to enable straightforward retrieval of parameter information.

Embodiments are also provided relating to the storage, querying, and retrieval of information of complex constructed types within an application infrastructure or framework. Certain embodiments allow that a schema is maintained which represents and stores types using post-relational structures. Further, embodiments provide that type information may be stored and/or retrieved within a column of a relevant software repository item.

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and other advantages and features of the invention can be obtained, a more particular description of the embodiments briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only example embodiments of the invention and are not therefore to be considered to be limiting of its scope, the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:

FIG. 1 illustrates a computing system in which embodiments described herein may operate;

FIG. 2 illustrates a database schema representative of a common language application framework;

FIG. 3 illustrates a portion of a database schema including constructs for storing an abstraction of a namespace for an application framework;

FIG. 4 illustrates a flowchart of a method by which information corresponding to an abstraction of a namespace for an application framework may be stored with application framework information in a queriable format;

FIG. 5 illustrates database constructs useful for storing parameter information in a database;

FIG. 6 illustrates a flowchart of a method whereby method information and parameter information may be stored such that the parameter information is retrievable with method information;

FIG. 7 illustrates a diagram of type information associated with constructed types as may be contained within an application framework; and

FIG. 8 illustrates a flowchart of a method whereby type information for constructed types within an application framework may be stored in such a way as to be queriable.

DETAILED DESCRIPTION

The present invention relates to the storage and retrieval of information pertaining to a common language application framework or infrastructure. The embodiments of the present invention may comprise a special purpose or general-purpose computer including various computer hardware, as discussed in greater detail below.

FIG. 1 illustrates a schematic diagram of an example computing system 100 that may be used to implement embodiments described herein. The described computing system is only one example of such a suitable computing system and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Neither should the invention be interpreted as having any dependency or requirement relating to any one or combination of components illustrated in FIG. 1.

Computing systems are now increasingly taking a wide variety of forms. Computing systems may, for example, be handheld devices, appliances, laptop computers, desktop computers, mainframes, distributed computing systems, or even devices that have not conventionally been considered a computing system. In this description and in the claims, the term “computing system” is defined broadly as including any device or system (or combination thereof) that includes at least one processor, and a memory capable of having thereon computer-executable instructions that may be executed by the processor. The memory may take any form and may depend on the nature and form of the computing system. A computing system may be distributed over a network environment and may include multiple constituent computing systems.

Referring to FIG. 1, in its most basic configuration, a computing system 100 typically includes at least one processing unit 102 and memory 104. The memory 104 may be system memory, which may be volatile, non-volatile, or some combination of the two. An example of volatile memory includes Random Access Memory (RAM). Examples of non-volatile memory include Read Only Memory (ROM), flash memory, or the like. The term “memory” may also be used herein to refer to non-volatile mass storage such as physical storage media. Such storage may be removable or non-removable, and may include (but is not limited to) PCMCIA cards, magnetic and optical disks, magnetic tape, and the like.

As used herein, the term “module” or “component” can refer to software objects or routines that execute on the computing system. The different components, modules, engines, and services described herein may be implemented as objects or processes that execute on the computing system (e.g., as separate threads). While the system and methods described herein may be implemented in software, implementations in hardware, and in combinations of software and hardware are also possible and contemplated.

In the description that follows, embodiments are described with reference to acts that are performed by one or more computing systems. If such acts are implemented in software, one or more processors of the associated computing system that performs the act direct the operation of the computing system in response to having executed computer-executable instructions. An example of such an operation involves the manipulation of data. The computer-executable instructions (and the manipulated data) may be stored in the memory 104 of the computing system 100.

Computing system 100 may also contain communication channels 108 that allow the computing system 100 to communicate with other computing systems over, for example, network 110. Communication channels 108 are examples of communications media. Communications media typically embody computer-readable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave or other transport mechanism and include any information-delivery media. By way of example, and not limitation, communications media include wired media, such as wired networks and direct-wired connections, and wireless media such as acoustic, radio, infrared, and other wireless media. The term computer-readable media as used herein includes both storage media and communications media.

Embodiments consistent with the principles described herein also include computer-readable media for carrying or having computer-executable instructions or data structures stored thereon. Such computer-readable media can be any available media that can be accessed by a general purpose or special purpose computer. By way of example, and not limitation, such computer-readable media can comprise physical computer-readable media such as RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to carry or store desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computer, the computer properly views the connection as a computer-readable medium. Thus, any such connection is properly termed a computer-readable medium. Combinations of the above should also be included within the scope of computer-readable media.

Computer-executable instructions comprise, for example, instructions and data which cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.

Generally, software repositories store data about software. The data may include the executable software, itself, the source code necessary to generate the software, and data about the software (i.e., metadata). Software repositories may take the form of databases and the databases may be implemented as flat files, as relational databases comprising tables, and as post-relational databases including post-relation schema, constructs, and structures such as XML columns. Of course, software repositories may take advantage of hybrid technologies comprising any or all of the available database technologies.

An example of an important domain for software repositories is the Microsoft®.NET CLR (the Common Language Runtime) (the “CLR”). The CLR is Microsoft's commercial implementation of the Common Language Infrastructure (CLI). The CLI specification is an international standard (i.e., Common Language Infrastructure (CLI), ECMA-335 (4th Ed., June 2006)) for creating development and execution environments in which languages & libraries work together seamlessly and in which applications written in multiple high-level languages can be executed in different system environments without the need to rewrite those applications to take into consideration the unique characteristics of those environments.

Unfortunately, like many common language frameworks, the metadata for the CLR and the CLI is structured to support compilers and runtimes but not browsing and report generation by customers. For example, many programming languages have the concept of namespaces (e.g., “System.Data”) that contain classes (e.g. “ClassConstraint”) so that “System.Data.ClassConstraint” identifies the class, ClassConstraint, within the namespace System.Data.

However, this namespace concept is not a concept within many common language frameworks or infrastructures (like the CLR and CLI). In many frameworks and infrastructures, the name “System.Data.ClassConstraint” is just a series of semantically meaningless characters which identifies a particular object. Despite not being inherently included within the frameworks or infrastructures, the namespace concept is a natural and useful one for many users. Because of this, it may be useful to structure common language framework domain schema and the database structures implementing those schema in such a way that users can naturally query it with queries like “what are all the classes in System.Data” but still allow compilers to easily query for the actual name of the included classes like “System.Data.ClassConstraint.”

Embodiments and principles described herein attempt to strike a balance between three competing forces—true common language framework semantics, programming language and user semantics, and performance. Embodiments and principles described herein provide for systems, methods, data structures, and computer program products which may store common language framework information and metadata which may be efficiently and easily queried by a wide variety of tools and which may be queried in fashions useful to both programmers and to compilers.

Embodiments and principles described herein may be implemented using a variety of tools, including database tools such as Microsoft®'s SQL Server 2005. However, reference to specific tools should be considered examples of a particular implementation or embodiment but not be considered to limit the invention in any way. The principles described herein may be implemented using any suitable tool as those with skill in the art may successfully employ.

In many common language frameworks and infrastructures (e.g., the CLR and CLI), basic types have two part identifiers consisting of an assembly name (e.g., “myD11,Version=1.0.0.1,Culture=neutral,PublicKeyToken=9b35aa32c18d4fb 1”) and a type name (e.g., “System.Collections.ArrayList”). However, some programming languages abstract this name as a namespace (e.g., “System.Collections”) followed by a type name (e.g., “ArrayList”). Further, other programming languages abstract this name as a path of namespaces (e.g., “System” and “Collections”) followed by a type name (e.g., “ArrayList”). Programmers and software developers, too, may sometimes think of such compound names are representative of a namespace.

In both programming language cases, however, the assembly is not specified since, by a common convention, the full namespace and type name should uniquely identify the class. Because of these differences, there are fundamental semantic differences in how types are represented in a common language framework or infrastructure (i.e., an application framework) and how they may advantageously be represented to suit different tools and different needs.

In certain embodiments, it may be beneficial to balance these differences in the representation of types by abstracting namespaces as software repository items. An example of such a schema including a representation of a namespace as a portion of a type's name is given in FIG. 3. Namespaces 310 may be associated with ClassesOrInterfaces 320, which, in turn, are associated with modules 340 and assemblies 330. The schema 300 illustrates a portion of a schema which, in particular embodiments, may be useful in the representation of the .NET CLR.

Within embodiments consistent with the principles herein, there are no nesting of namespaces. Thus, “System” and “System.Collections” may be separate and unrelated namespaces. This separation would allow normal repository tools to straightforwardly and efficiently query for type data using either the semantics of common language frameworks (e.g., the .NET CLR or CLI) or other programming language semantics (as described above). Embodiments employing this principle would also have the advantage of removing common type name prefixes like “System.Collections.” from type names and thereby reduce software repository storage costs or improve software repository query efficiency.

The embodiments an principles which are described herein may be practiced using the computing equipment as illustrated in FIG. 1 and described above. In particular, database schemas and structures 120 useful in to practice the principles presented may be contained or instantiated, permanently or temporarily, within computer memory 104 of a computing system 100. Further, the executable code 130 and procedures useful to practice the principles presented may also be stored or instantiated, permanently or temporarily, within the computer memory 104 and may be executed on the processor(s) 102 of the computing system 100.

FIG. 4 illustrates a flowchart 400 for a method whereby namespace information may be stored and retrieved in connection with a software repository. In order that the namespace be maintained, the method includes an act 410 of maintaining a schema corresponding to an application framework. The application framework may be any application framework or infrastructure. Examples of such application frameworks and infrastructures include the Microsoft®.NET CLR and the CLI. An example schema 200 for the .NET CLR is given in FIG. 2. However, a similar schema may be created for another application framework and variations of the schema in FIG. 2 should also be considered to be consistent with the principles herein. No particular schema should be considered limiting and any schema consistent with the principles herein should be considered to be within the scope of the embodiments herein.

The schema which is defined and maintained by the computing system may comprise post-relational schema constructs. In particular embodiments, it may be advantageous to use constructs like XML columns to represent repository items within the schema.

Once a schema is defined for the application framework or infrastructure, an act 420 of maintaining database structures instantiates and maintains database structures corresponding to the schema of 410 within the computing system. The structures maintained in the act 420 do not necessarily have to physically be structured to correspond exactly as the schema is defined in act 410. There may be different physical, logical, or virtual structures which provide the database structures as described by the schema corresponding to the application framework.

Once a database structure is instantiated and maintained on the computing system, an act 430 of storing information corresponding to some portion of the application framework is employed. In certain embodiments, it may be useful to store complete information corresponding to the application framework or infrastructure. In other embodiments, because of time, space, or other constraints, it may be useful to store only a subset of the complete information corresponding to a particular application framework.

To complete the method 400, there is an act 440 of storing information within the database structure which corresponds to an abstraction of a namespace corresponding to the application framework. Although the application framework, itself, may not actually embody the concept of a namespace, the information corresponding to an abstraction of a namespace may still be stored by application of the principles described herein.

In particular embodiments of the principles herein, the information corresponding to an abstraction of a namespace corresponding to the application framework is queriable. In certain embodiments, standard SQL queries may provide the proper tools for such queries. In other embodiments, specific or ad hoc tools may provide access to such queries. The specific tool used to effect such queries should not be considered limiting and any tool, extant or ad hoc, should be considered consistent with the principles herein.

For example, if a type name in an application framework is “System.Collections.TypeName” the information corresponding to the abstraction of the namespace for the particular application framework which will be stored may include both “System” and “System.Collections”. In this fashion, a query for “all the types in System” will return “TypeName” (as well as other types with names such as “System.Foo.AnotherType”). Similarly, a query for all the types within “System.Collections” will also return “TypeName” (as well as other types with names such as “System.Collections.AnotherType” and “System.Collections.Foo.AnotherType”).

Consistent with the principles herein are also computer program products which comprise computer-readable storage media and have computer-executable instructions encoded thereon which, when executed by suitable computer systems, will execute the methods or instantiate the embodiments described herein.

Also consistent with the principles herein are computer systems comprising computer-readable memory and computer processors upon which is implemented the embodiments and principles as described herein.

When retrieving information about a type's methods, it is often convenient to also retrieve information about the type's parameters. However, a standard relational representation of a type's parameters would be inefficient since the parameters would need to be stored in a separate table and, most likely, retrieved separately.

By using post-relational database constructs like nested relations, XML columns, and collection types, it may be possible to store, query, and retrieve the parameters of a method in a column together with other method data. For many software repository queries, applying this in certain embodiments may result in performance improvements.

FIG. 5 illustrates a schema and structures consistent with these principles. The Methods Table 510 shows how parameters may be contained within a methods column. Diagram 520 illustrates a representation of a method's parameters which may be included within the relevant repository item. The parameter representation 520 is illustrated using a post-relational hierarchical tree.

FIG. 6 illustrates a flowchart 600 of a method of representing and storing parameter information corresponding to methods as contained within an application framework or infrastructure. The application framework may be any application framework or infrastructure and examples of such application frameworks and infrastructures include the Microsoft®.NET CLR and the CLI. The method includes an act 610 of maintaining a schema corresponding to an application framework. An example schema for the .NET CLR is illustrated in FIG. 2. However, a similar schema may be created for another application framework and variations of the schema in FIG. 2 would also be consistent with the principles herein.

The schema which is defined and maintained by the computing system may comprise post-relational schema constructs. In particular embodiments, it may be advantageous to use constructs like XML columns to represent repository items within the schema. No particular schema should be considered limiting and any schema consistent with the principles herein should be considered to be within the scope of the embodiments herein.

Once a schema is defined for the application framework or infrastructure, an act 620 of maintaining database structures instantiates and maintains database structures corresponding to the schema of 610 within the computing system. The structures maintained in the act 620 do not necessarily have to physically be structured to correspond exactly as the schema is defined and maintained in act 610. There may be different physical, logical, or virtual structures which provide the database structures as described by the schema corresponding to the application framework.

Once a database structure is instantiated and maintained on the computing system, an act 630 of storing information within the database structure corresponding to one or more methods within application framework is employed. In certain embodiments, it may be useful to store complete information corresponding to the application framework or infrastructure. In other embodiments, because of time, space, or other constraints, it may be useful to store only some subset of the complete information corresponding to a particular application framework. In FIG. 2, the column entitled “MethodsTable” illustrates example information corresponding to methods within an application framework which may be stored within the database structure.

The method further includes an act 640 of storing information within the database structure corresponding to parameters of the one or more methods. The information of the one or more methods is such that a method's parameters may be queried and/or retrieved as associated with the methods.

The “MethodsTable” of FIG. 2 illustrates that a field within the column provides parameter information. The diagram 520 of FIG. 5 illustrates an example representation of parameter information which may be stored, queried, and retrieved as associated with a method. The “MethodsTable” 510 of FIG. 5 merely illustrates a shortened version of the MethodsTable as illustrated in FIG. 2.

The actual type of schema or database structure consistent with the principles herein should be considered limited but be considered to include post-relational constructs. The storing of information corresponding to methods of an application framework and the storing of information corresponding to parameters of methods should also be considered to include storing the information within post-relational constructs. Such post-relational constructs include nested relations, XML, XML columns, and collection types.

In particular embodiments of the principles herein, the information corresponding to methods and to methods' parameters is queriable. In certain embodiments, it may be possible to compose and execute queries such as “what are the parameters of “FooMethod.” In certain embodiments, standard SQL queries may provide the proper tools for such queries. In other embodiments, specific or ad hoc tools may provide access to such queries. The specific tool used to effect such queries should not be considered limiting and any tool, extant or ad hoc, should be considered consistent with the principles herein. It may also be possible, in certain embodiments, to execute queries such as “what are the types of the parameters of FooMethod” or, as described above, queries like “what are the types of the parameters of the methods within System.Collections.”

Consistent with the principles herein are also computer program products which comprise computer-readable storage media and have computer-executable instructions encoded thereon which, when executed by suitable computer systems, will execute the methods or instantiate the embodiments described herein.

Also consistent with the principles herein are computer systems comprising computer-readable memory and computer processors upon which is implemented the embodiments and principles as described herein.

Common language frameworks and infrastructures like the Microsoft® .NET CLR and CLI often allow the types of fields, parameters, variables, and method return values to have an arbitrary complexity. Types are allowed to be defined and constructed in terms of more primitive types in arbitrary ways and to an arbitrary degree of complexity. Further, tool specific extensions to a common language runtime's type system are generally permitted.

Representing such constructed types using a standard relational approach may mean that common software repository queries (e.g., “what type does this method return”) would be complex, difficult for a software developer to write, and inefficient to execute against the repository. It may be that the construction of such complex queries involving such constructed types may be well beyond the abilities of many software developers.

In certain embodiments, it may be advantageous to represent types using a post-relational schema and/or structure. An XML column is an example of such a suitable post-relational construct. Using such post-relational constructs may produce a compact and queriable representation which may then be stored in a column of a relevant repository item such as a field or a parameter. FIG. 7 illustrates a representation 700 of a such a constructed type.

FIG. 8 illustrates a flowchart 800 of a method of storing and maintaining information corresponding to one or more types within an application framework or infrastructure. The method includes an act 810 of maintaining a schema corresponding to a software repository in which types may be represented. The types may be constructed types (but are not necessarily limited to such constructed types). The schema may correspond to an entire application framework (or subset thereof) and may be any application framework or infrastructure. Examples of such application frameworks and infrastructures include the .NET CLR and the CLI.

An example schema for the .NET CLR is given in FIG. 2. However, a similar schema may be created for another application framework and variations of the schema in FIG. 2 would also be consistent with the principles herein. No particular schema should be considered limiting and any schema consistent with the principles herein should be considered to be within the scope of the embodiments herein.

The method also includes an act 820 of representing types using a post-relational structure. An example of such post relational structures includes an XML column. The particular structure should not be considered limiting, however, and any structure consistent with the principles herein should be considered to be included.

Once a schema corresponding to a software repository is defined and maintained and types are represented, an act 830 of maintaining database structures instantiates and maintains database structures within the computing system corresponding to the schema. The structures maintained in the act 830 do not necessarily have to physically be structured to correspond exactly as the schema is defined in act 810. There may be different physical, logical, or virtual structures which provide the database structures faithful to and as described by the schema corresponding to the software repository.

The software repository and the represented types may correspond to that of a particular application framework or infrastructure. Examples of such application frameworks and infrastructures include the .NET CLR and the CLI. An example schema for the .NET CLR is given in FIG. 2. However, a similar schema may be created for another application framework and variations of the schema in FIG. 2 would also be consistent with the principles herein. No particular schema should be considered limiting and any schema consistent with the principles herein should be considered to be within the scope of the embodiments herein.

Once a database structure is instantiated and maintained on the computing system corresponding to the schema, the method includes an act 840 of storing information corresponding to one or more types within the database structure. The act 840 of storing stores the information in such a way that the information corresponding to the type can be stored within a column of a relevant repository item.

In certain embodiments, it may be useful to store complete information corresponding to an application framework or infrastructure. In other embodiments, because of time, space, or other constraints, it may be useful to store only a subset of the complete information corresponding to a particular application framework which includes type information.

Type information may be associated with or stored within any relevant repository item. The repository item may represent a field, a parameter, a method return type or value.

The schema may be designed and maintained and the database structure(s) may be instantiated and maintained in such a way as to make the information corresponding to types queriable. In certain embodiments, it is possible to compose and execute such queries as “what is the type description of the parameters of FooMethod” or “what is the type of the return value upon completion of the method FooBarMethod.”

Of course, the principles described herein may be practiced singly, separately, or in combination with all the principles described (and in combination with other principles as may also known by those with skill in the art).

The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope. 

1. A computer-implemented method for storing a common language application framework in order to produce a queriable representation of the common language application framework, the method comprising: maintaining a schema in computer memory corresponding to the application framework; maintaining a database structure in computer memory corresponding to the schema; storing information within the database structure corresponding to at least some portion of the application framework; and storing information within the database structure corresponding to an abstraction of a namespace corresponding to the application framework.
 2. The method of claim 1 wherein the schema comprises a post-relational schema and the database structure comprises post-relational structures. (XML columns, etc.)
 3. The method of claim 1 wherein the common language application framework is the CLI.
 4. The method of claim 1 wherein the common language application framework is the .NET CLR.
 5. The method of claim 1 wherein the information corresponding to an abstraction of a namespace corresponding to the application framework is queriable. (standard SQL queries, etc.)
 6. A computer program product comprising computer-readable storage media having computer-executable instructions encoded thereon which, when executed by suitable computing equipment, implements the method of claim
 1. 7. A computer system comprising computer-readable memory and one or more computer processors upon which is implemented the method of claim
 1. 8. A computer-implemented method for storing queriable information corresponding to methods and parameters of a common language framework, the method comprising: maintaining a schema corresponding to a common language application framework; maintaining a database structure within the computer corresponding to the schema; storing information within the database structure corresponding to one or more methods within the application framework; and storing information within the database structure corresponding to parameters of the one or more methods such that information corresponding to the method's parameters may be queried, and retrieved as associated with the methods.
 9. The method of claim 8 wherein the schema is a post-relational schema.
 10. The method of claim 8 wherein the common language framework is the CLI.
 11. The method of claim 8 wherein the common language framework is the .NET CLR
 12. The method of claim 8 wherein the database structure into which methods' information is stored represents at least one of nested relations, XML, or collection types.
 13. A computer program product comprising computer-readable storage media having computer-executable instructions encoded thereon which, when executed by suitable computing equipment, implements the method of claim
 8. 14. A computer system comprising computer-readable memory and one or more computer processors upon which is implemented the method of claim
 8. 15. A computer-implemented method for representing types within a common language to produce a queriable representation which can be stored in a software repository, the method comprising: maintaining a schema within the computer corresponding to a software repository in which constructed types may be represented; representing types within the schema using a post-relational structure; maintaining a database structure within the computer corresponding to the schema; and storing information corresponding to one or more types within the database structure, such that the information corresponding to the type can be stored within a column of a relevant repository item.
 16. The method of claim 15 wherein the repository item represents a field.
 17. The method of claim 15 wherein the repository item represents a parameter.
 18. The method of claim 15 wherein the repository item represents a return value.
 19. The method of claim 15 wherein the schema comprises a post-relational structure.
 20. The method of claim 15 wherein the types represented are types of at least one of the CLI or the .NET CLR. 